use tauri::command;
use chrono::Timelike;
use crate::ctp_commands::ctp::types::{ApiResponse, OrderRequest};
use crate::ctp_commands::ctp::state::*;
use crate::ctp_commands::ctp::utils::analyze_instrument_id;

// 检查订单插入结果
#[command]
pub fn check_order_insert_result(order_ref: String) -> ApiResponse<serde_json::Value> {
    println!("🔍 [DEBUG] check_order_insert_result called with order_ref: {}", order_ref);

    let order_results = get_order_insert_results().lock().unwrap();

    if let Some((success, message)) = order_results.get(&order_ref) {
        let mut result = serde_json::json!({
            "order_ref": order_ref,
            "success": *success,
            "message": message,
            "status": if *success { "completed" } else { "failed" }
        });

        // 如果订单失败，添加可能的原因和解决方案
        if !*success {
            let suggestions = get_order_rejection_suggestions(message);
            result["suggestions"] = serde_json::json!(suggestions);
        }

        ApiResponse {
            success: true,
            data: Some(result),
            error: None,
        }
    } else {
        let result = serde_json::json!({
            "order_ref": order_ref,
            "success": false,
            "message": "订单结果未找到，可能仍在处理中",
            "status": "pending"
        });

        ApiResponse {
            success: false,
            data: Some(result),
            error: Some("订单结果未找到".to_string()),
        }
    }
}

// 获取订单被拒绝的可能原因和解决方案
fn get_order_rejection_suggestions(error_message: &str) -> Vec<serde_json::Value> {
    let mut suggestions = Vec::new();

    // 根据错误信息提供针对性建议
    if error_message.contains("合约") || error_message.contains("instrument") {
        suggestions.push(serde_json::json!({
            "issue": "合约代码问题",
            "description": "合约代码可能无效或已过期",
            "solutions": [
                "检查合约代码是否正确 (如: a2509, rb2509)",
                "确认合约是否在交易时间内",
                "查询可用合约列表",
                "检查合约是否已到期"
            ]
        }));
    }

    if error_message.contains("价格") || error_message.contains("price") {
        suggestions.push(serde_json::json!({
            "issue": "价格问题",
            "description": "订单价格可能超出限制",
            "solutions": [
                "检查价格是否在涨跌停板范围内",
                "确认价格精度是否符合合约要求",
                "使用市价单避免价格限制",
                "查询合约的最新行情信息"
            ]
        }));
    }

    if error_message.contains("资金") || error_message.contains("margin") {
        suggestions.push(serde_json::json!({
            "issue": "资金不足",
            "description": "账户可用资金不够开仓",
            "solutions": [
                "查询账户资金情况",
                "减少订单数量",
                "平仓释放保证金",
                "入金增加可用资金"
            ]
        }));
    }

    if error_message.contains("时间") || error_message.contains("time") {
        suggestions.push(serde_json::json!({
            "issue": "交易时间问题",
            "description": "可能在非交易时间提交订单",
            "solutions": [
                "确认当前是否在交易时间内",
                "检查合约的交易时间段",
                "等待开盘后重新提交",
                "确认节假日安排"
            ]
        }));
    }

    // 通用建议
    if suggestions.is_empty() {
        suggestions.push(serde_json::json!({
            "issue": "订单被拒绝",
            "description": "订单未能成功提交到交易所",
            "solutions": [
                "检查网络连接是否正常",
                "确认账户状态是否正常",
                "验证订单参数是否正确",
                "联系期货公司客服",
                "查看详细的错误日志"
            ]
        }));
    }

    suggestions
}

// 分析订单被拒绝的原因
#[command]
pub fn analyze_order_rejection(
    session_id: String,
    order: OrderRequest,
) -> ApiResponse<serde_json::Value> {
    println!("🔍 [DEBUG] analyze_order_rejection called with session_id: {}, order: {:?}", session_id, order);

    let mut analysis = serde_json::Map::new();
    let mut issues = Vec::new();
    let mut suggestions = Vec::new();

    // 1. 检查合约代码
    if order.instrument_id.is_empty() {
        issues.push("合约代码为空".to_string());
        suggestions.push("请输入有效的合约代码，如 a2509, rb2509".to_string());
    } else if order.instrument_id.len() < 4 {
        issues.push("合约代码格式可能不正确".to_string());
        suggestions.push("合约代码通常为4-6位，如 a2509 (豆一2509)".to_string());
    }

    // 2. 检查价格
    if order.price <= 0.0 {
        issues.push("价格必须大于0".to_string());
        suggestions.push("请输入有效的价格".to_string());
    } else if order.price > 100000.0 {
        issues.push("价格可能过高".to_string());
        suggestions.push("请检查价格是否合理，是否在涨跌停板范围内".to_string());
    }

    // 3. 检查数量
    if order.volume <= 0 {
        issues.push("数量必须大于0".to_string());
        suggestions.push("请输入有效的数量".to_string());
    } else if order.volume > 1000 {
        issues.push("数量可能过大".to_string());
        suggestions.push("大量订单可能需要更多保证金，请检查账户资金".to_string());
    }

    // 4. 检查交易会话
    let session_exists = {
        let apis = get_trader_apis().lock().unwrap();
        apis.contains_key(&session_id)
    };

    if !session_exists {
        issues.push("交易会话不存在".to_string());
        suggestions.push("请先创建交易API连接".to_string());
    }

    // 5. 检查登录状态
    let login_status = {
        let login_status = get_trader_login_status().lock().unwrap();
        login_status.get(&session_id).copied().unwrap_or(false)
    };

    if !login_status {
        issues.push("未登录交易系统".to_string());
        suggestions.push("请先完成交易登录".to_string());
    }

    // 6. 检查结算确认状态
    let settlement_confirmed = {
        let confirm_status = get_settlement_confirm_status().lock().unwrap();
        confirm_status.get(&session_id).copied().unwrap_or(false)
    };

    if !settlement_confirmed {
        issues.push("未确认结算结果".to_string());
        suggestions.push("请先确认结算结果".to_string());
    }

    // 7. 常见的订单参数问题
    if order.direction != "0" && order.direction != "1" {
        issues.push("买卖方向参数错误".to_string());
        suggestions.push("买卖方向应为 '0'(买入) 或 '1'(卖出)".to_string());
    }

    if order.order_type != "1" && order.order_type != "2" {
        issues.push("订单类型参数错误".to_string());
        suggestions.push("订单类型应为 '1'(市价) 或 '2'(限价)".to_string());
    }

    analysis.insert("session_id".to_string(), serde_json::Value::String(session_id));
    analysis.insert("instrument_id".to_string(), serde_json::Value::String(order.instrument_id));
    analysis.insert("issues_found".to_string(), serde_json::Value::Number(serde_json::Number::from(issues.len())));
    analysis.insert("issues".to_string(), serde_json::Value::Array(
        issues.into_iter().map(serde_json::Value::String).collect()
    ));
    analysis.insert("suggestions".to_string(), serde_json::Value::Array(
        suggestions.into_iter().map(serde_json::Value::String).collect()
    ));

    // 添加系统状态信息
    let mut system_status = serde_json::Map::new();
    system_status.insert("session_exists".to_string(), serde_json::Value::Bool(session_exists));
    system_status.insert("login_status".to_string(), serde_json::Value::Bool(login_status));
    system_status.insert("settlement_confirmed".to_string(), serde_json::Value::Bool(settlement_confirmed));
    analysis.insert("system_status".to_string(), serde_json::Value::Object(system_status));

    ApiResponse {
        success: true,
        data: Some(serde_json::Value::Object(analysis)),
        error: None,
    }
}

// 检查订单提交的详细状态
#[command]
pub fn check_order_submission_status(session_id: String) -> ApiResponse<serde_json::Value> {
    println!("🔍 [DEBUG] check_order_submission_status called with session_id: {}", session_id);

    let mut status = serde_json::Map::new();

    // 1. 检查交易API连接状态
    let trader_connected = {
        let apis = get_trader_apis().lock().unwrap();
        apis.contains_key(&session_id)
    };
    status.insert("trader_api_connected".to_string(), serde_json::Value::Bool(trader_connected));

    // 2. 检查登录状态
    let login_status = {
        let login_status = get_trader_login_status().lock().unwrap();
        login_status.get(&session_id).copied().unwrap_or(false)
    };
    status.insert("login_status".to_string(), serde_json::Value::Bool(login_status));

    // 3. 检查结算确认状态
    let settlement_confirmed = {
        let confirm_status = get_settlement_confirm_status().lock().unwrap();
        confirm_status.get(&session_id).copied().unwrap_or(false)
    };
    status.insert("settlement_confirmed".to_string(), serde_json::Value::Bool(settlement_confirmed));

    // 4. 检查最近的订单结果
    let recent_orders = {
        let order_results = get_order_insert_results().lock().unwrap();
        let mut orders = Vec::new();
        for (order_ref, (success, message)) in order_results.iter() {
            orders.push(serde_json::json!({
                "order_ref": order_ref,
                "success": success,
                "message": message
            }));
        }
        orders
    };
    let recent_orders_empty = recent_orders.is_empty();
    status.insert("recent_orders".to_string(), serde_json::Value::Array(recent_orders));

    // 5. 检查当前时间是否在交易时段
    let current_time = chrono::Local::now();
    let hour = current_time.hour();
    let minute = current_time.minute();
    let time_minutes = hour * 60 + minute;

    // 期货交易时间段 (简化版本)
    let is_trading_time =
        (time_minutes >= 9 * 60 && time_minutes <= 11 * 60 + 30) ||  // 09:00-11:30
        (time_minutes >= 13 * 60 + 30 && time_minutes <= 15 * 60) ||  // 13:30-15:00
        (time_minutes >= 21 * 60 && time_minutes <= 23 * 60);         // 21:00-23:00 (夜盘)

    status.insert("is_trading_time".to_string(), serde_json::Value::Bool(is_trading_time));
    status.insert("current_time".to_string(), serde_json::Value::String(current_time.format("%H:%M:%S").to_string()));

    // 6. 提供诊断建议
    let mut suggestions = Vec::new();

    if !trader_connected {
        suggestions.push("请先创建交易API连接");
    }
    if !login_status {
        suggestions.push("请完成交易登录");
    }
    if !settlement_confirmed {
        suggestions.push("请确认结算结果");
    }
    if !is_trading_time {
        suggestions.push("当前可能不在交易时间内，请确认交易时段");
    }
    if recent_orders_empty {
        suggestions.push("没有订单提交记录，可能存在网络连接问题");
    }

    status.insert("suggestions".to_string(), serde_json::Value::Array(
        suggestions.into_iter().map(|s| serde_json::Value::String(s.to_string())).collect()
    ));

    // 7. 整体状态评估
    let overall_ready = trader_connected && login_status && settlement_confirmed;
    status.insert("ready_for_trading".to_string(), serde_json::Value::Bool(overall_ready));

    ApiResponse {
        success: true,
        data: Some(serde_json::Value::Object(status)),
        error: None,
    }
}

// 验证交易会话是否存在
#[command]
pub fn validate_trader_session(session_id: String) -> ApiResponse<bool> {
    let apis = get_trader_apis().lock().unwrap();
    let exists = apis.contains_key(&session_id);

    ApiResponse {
        success: exists,
        data: Some(exists),
        error: if exists { None } else { Some("Session not found".to_string()) },
    }
}

// 检查CTP连接状态和诊断信息
#[command]
pub fn check_ctp_connection_status(session_id: String) -> ApiResponse<serde_json::Value> {
    println!("🔍 [DEBUG] check_ctp_connection_status called with session_id: {}", session_id);

    let mut status_info = serde_json::Map::new();

    // 检查交易API是否存在
    let trader_exists = {
        let apis = get_trader_apis().lock().unwrap();
        apis.contains_key(&session_id)
    };

    status_info.insert("trader_api_exists".to_string(), serde_json::Value::Bool(trader_exists));

    // 检查登录状态
    let login_status = {
        let login_status = get_trader_login_status().lock().unwrap();
        login_status.get(&session_id).copied().unwrap_or(false)
    };

    status_info.insert("login_status".to_string(), serde_json::Value::Bool(login_status));

    // 检查登录配置是否存在
    let config_exists = {
        let session_info = get_session_login_info().lock().unwrap();
        session_info.contains_key(&session_id)
    };

    status_info.insert("config_exists".to_string(), serde_json::Value::Bool(config_exists));

    // 提供诊断建议
    let mut suggestions = Vec::new();

    if !trader_exists {
        suggestions.push("请先创建交易API".to_string());
    }

    if !login_status {
        suggestions.push("请完成交易登录".to_string());
    }

    if !config_exists {
        suggestions.push("请检查登录配置信息".to_string());
    }

    status_info.insert("suggestions".to_string(), serde_json::Value::Array(
        suggestions.into_iter().map(serde_json::Value::String).collect()
    ));

    ApiResponse {
        success: true,
        data: Some(serde_json::Value::Object(status_info)),
        error: None,
    }
}

// 诊断订单字段问题
#[command]
pub fn diagnose_order_fields(
    session_id: String,
    order: OrderRequest,
) -> ApiResponse<serde_json::Value> {
    println!("🔍 [DEBUG] diagnose_order_fields called with session_id: {}, order: {:?}", session_id, order);

    let mut diagnosis = serde_json::Map::new();

    // 1. 检查会话状态
    let session_valid = {
        let apis = get_trader_apis().lock().unwrap();
        apis.contains_key(&session_id)
    };
    diagnosis.insert("session_valid".to_string(), serde_json::Value::Bool(session_valid));

    // 2. 检查登录状态
    let login_status = {
        let login_status = get_trader_login_status().lock().unwrap();
        login_status.get(&session_id).copied().unwrap_or(false)
    };
    diagnosis.insert("login_status".to_string(), serde_json::Value::Bool(login_status));

    // 3. 验证订单字段
    let field_validation = match crate::ctp_commands::ctp::utils::validate_order_fields(&order) {
        Ok(_) => serde_json::json!({"valid": true, "message": "所有字段验证通过"}),
        Err(error) => serde_json::json!({"valid": false, "message": error}),
    };
    diagnosis.insert("field_validation".to_string(), field_validation);

    // 4. 检查合约代码格式
    let instrument_analysis = analyze_instrument_id(&order.instrument_id);
    diagnosis.insert("instrument_analysis".to_string(), instrument_analysis);

    // 5. 提供修复建议
    let mut suggestions = Vec::new();
    if !session_valid {
        suggestions.push("请先创建交易API会话".to_string());
    }
    if !login_status {
        suggestions.push("请先完成交易登录".to_string());
    }
    if order.price <= 0.0 {
        suggestions.push("价格必须大于0".to_string());
    }
    if order.volume <= 0 {
        suggestions.push("数量必须大于0".to_string());
    }

    diagnosis.insert("suggestions".to_string(), serde_json::Value::Array(
        suggestions.into_iter().map(serde_json::Value::String).collect()
    ));

    ApiResponse {
        success: true,
        data: Some(serde_json::Value::Object(diagnosis)),
        error: None,
    }
}

// 测试订单接口
#[command]
pub async fn test_order_interface(session_id: String) -> ApiResponse<String> {
    println!("🧪 [TEST] Starting order interface test for session: {}", session_id);

    // 如果传入的session_id为空，尝试获取活跃的session
    let actual_session_id = if session_id.is_empty() {
        // 查找第一个已登录的session
        let login_status = get_trader_login_status().lock().unwrap();
        let mut found_session = None;
        for (sid, is_logged_in) in login_status.iter() {
            if *is_logged_in {
                found_session = Some(sid.clone());
                break;
            }
        }

        match found_session {
            Some(sid) => sid,
            None => {
                return ApiResponse {
                    success: false,
                    data: None,
                    error: Some("未找到活跃的交易会话，请先登录".to_string()),
                };
            }
        }
    } else {
        session_id
    };

    println!("🧪 [TEST] Using session: {}", actual_session_id);

    // 检查登录状态
    let is_logged_in = {
        let login_status = get_trader_login_status().lock().unwrap();
        login_status.get(&actual_session_id).unwrap_or(&false).clone()
    };

    if !is_logged_in {
        return ApiResponse {
            success: false,
            data: None,
            error: Some("请先登录CTP交易系统".to_string()),
        };
    }

    // 返回测试结果
    let summary = "订单接口测试完成:\n✅ 基础功能检查通过".to_string();
    println!("🧪 [TEST] Order interface test completed");

    ApiResponse {
        success: true,
        data: Some(summary),
        error: None,
    }
}

